gsk: Add specific debug type for shaders

So that we don't lose GskShaderBuilder debugging messages in the stream
of GskGLRenderer ones.

gsk: Add GskGLDriver

We can move the caching and management of textures, VAOs, and state of
the GL machinery into a single object, GskGLDriver.

gsk: Use the right pointer to the parent RenderItem

We copy the local RenderItem into the render items array, so we need to
use the copy in the array in order to get the correct reference.

Ensure that render nodes are translated

The clip rectangle may have non-zero offsets, so we need to ensure that
the GskRenderNode associated to the rendered area is translated by those
same offsets.

gsk: Add fundamental type annotations for GskRenderNode

We need to annotate the GskRenderNode so that the introspection
machinery can find the functions for managing reference counting
and GValues.

gsk: Add 'blit' program

For the root node we do not need to use blending, as it does not have
any backdrop to blend into. We can use a simpler 'blit' program that
only takes the content of the source and fills the texture quad with
it.

gsk: Consolidate program creation and storage

We should use ShaderBuilder to create and store programs for the GL
renderer. This allows us to simplify the creation of programs (by moving
the compilation phase into the ShaderBuilder::create_program() method),
and move towards the ability to create multiple programs and just keep a
reference to the program id.

docs: Add more GSK documentation

gsk: Add more modes to the blend shader

Use the compositing CSS spec at:

  https://www.w3.org/TR/compositing-1/#blending

For the implementation.

gsk: Don't store the uniform and attribute location twice

We should keep the ShaderBuilder around and use it to query the various
uniform and attribute locations when needed, instead of storing those
offsets into the Renderer instance, and copying them. This allows a bit
more flexibility, once we have more than one program built into the
renderer.

gsk: Add getter for program id in ShaderBuilder

Since we store it into the ShaderBuilder instance we should also allow
getting the program id.

gsk: Add debugging notes to ShaderBuilder

Print out the generated shader and the list of available uniforms and
attributes.

gsk: Rework how GLSL shaders are built

The GL renderer should build the GLSL shaders using GskShaderBuilder.
This allows us to separate the common parts into separate files, and
assemble them as necessary, instead of shipping one big shader per type
of GL API (GL3, GL legacy, and GLES).

gsk: Add ShaderBuilder

GskShaderBuilder is an ancillary, private type that deals with the
internals of taking GLSL shaders from resources and building them,
with the additional feature of being able to compose shaders from a
common preamble, as well as adding conditional defines (useful for
enabling debugging code in the shaders themselves).

gsk: Add rendering debug mode for shaders

It's going to be useful to inject debugging data into the shaders used
by GSK.

gdk: Add more GDK_GL_ERROR error ids

We're going to use them in other locations.

gsk: Use the node's blend mode in the GL renderer

gsk: Store blend mode in the render node

gsk: Make GskBlendMode enumeration public

gsk: Allow sampling between parent and child nodes

gsk: Group render state attributes

gsk: Turn GskRenderNode into a pure GTypeInstance

Using GObject as the base type for a transient tree may prove to be too
intensive, especially when creating a lot of node instances. Since we
don't need properties or signals, and we don't need complex destruction
semantics, we can use GTypeInstance directly as the base type for
GskRenderNode.

gtk: Use GskRenderNode to render widgets

We need a virtual function to retrieve the GskRenderNode for each
widget, which is supposed to attach its own children's GskRenderNodes.
Additionally, we want to maintain the existing GtkWidget::draw mechanism
for widgets that do not implement get_render_node() — as well as widgets
that have handlers connected to the ::draw signal.

gtk: Add a GskRenderer to GtkWindow

Each top-level should have its own GskRenderer, to be used when drawing
the render node tree.

gsk: Rework GskRenderer and GskRenderNode semantics

This commit changes the way GskRenderer and GskRenderNode interact and
are meant to be used.

GskRenderNode should represent a transient tree of rendering nodes,
which are submitted to the GskRenderer at render time; this allows the
renderer to take ownership of the render tree. Once the toolkit and
application code have finished assembling it, the render tree ownership
is transferred to the renderer.

gsk: Flush the GL render items cache

Whenever the render tree changes we want to drop the RenderItem arrays,
as each item contains a pointer to the GskRenderNode which becomes
dangling once the root node changed.

gsk: Add GskRenderer::clear_tree

We need a way to clear eventual caches inside GskRenderer subclasses if
the root node has changed.

gsk: Port GskGLRenderer to GLES

Use the appropriate API and shaders if the GdkGLContext was created for
OpenGL ES instead of OpenGL.

gsk: Use surface-to-texture utility function

Now that we have it.

gsk: Rename shaders for OpenGL

gdk: Add utility for uploading Cairo surfaces to GL

The surface-to-GL upload logic has become more complicated with the
addition of the GLES code paths; it's more logical to have a public
utility function that can be called from GDK users, instead of copy
pasting the whole thing multiple times.

build: Add GSK deps to GTK

Initial implementation of GSK rendering pipeline

GSK is conceptually split into two scene graphs:

 * a simple rendering tree of operations
 * a complex set of logical layers

The latter is built on the former, and adds convenience and high level
API for application developers.

The lower layer, though, is what gets transformed into the rendering
pipeline, as it's simple and thus can be transformed into appropriate
rendering commands with minimal state changes.

The lower layer is also suitable for reuse from more complex higher
layers, like the CSS machinery in GTK, without necessarily port those
layers to the GSK high level API.

This lower layer is based on GskRenderNode instances, which represent
the tree of rendering operations; and a GskRenderer instance, which
takes the render nodes and submits them (after potentially reordering
and transforming them to a more appropriate representation) to the
underlying graphic system.

gsk: Initial commit / build environment

label: Avoid shadowing variables

Update POTFILES.in

Add a test for cursor names

This tests both that all standard cusor yield a cursor, and that
unknown cursor names yield NULL.

x11: Add the same message as the wayland backend has

This seems prudent, if we make noise about missing cursors
on Wayland, we should do the same on X11.

Reduce a warning to a message

The warning interferes with having a testcase to check this behavior,
so reduce this to a message.

Remove GtkAction

Remove GtkActionGroup

Fix unittests

widget: Not all toplevels are also containers

tests/testylecontext: Don't double-free widgetpath

Remove GtkRecentAction

Remove GtkUIManager

Remove GtkActivatable

recentchooser: Stop implementing GtkActivatable

recentchooserdefault: Stop implementing GtkActivatable

toolitem: Stop implementing GtkActivatable

Remove GtkToggleAction

Remove GtkRadioAction

Remove GtkStock

infobar: Stop looking at stock items

GtkButton doesn't have a use-stock property anymore anyway.

window: Remove decoration-button-layout style property

GtkSettings has a gtk-decoration-layout property for this.

window: Remove decoration-resize-handle style property

toolbar: Remove max-child-expand child property

Remove GtkAlignment

gtkapplication: Remove deprecated API

treeview: Remove deprecated adjustment API

combobox: Remove deprecated API

adjustment: Remove deprecated API

menutoolbutton: Remove deprecated API

popover: Remove deprecated API

range: Remove unused class struct members

filechooserbutton: Remove deprecated API

messagedialog: Remove deprecated API

button: Add icon-name property

Remove the old-style button construction that allowed to show both an
icon and a label and change visibility based on a GtkSetting.

testsuite/gtk: Use a GtkMenuButton to test exposing objects

docs/tools/widgets: Stop using gtk_button_set_image

buttonaccessible: Stop looking at the button's image

tests: Add testgaction.c

radiomenuitem: Remove GtkActivatable code

toolbutton: Stop implementing GtkActivatable

switch: Stop implementing GtkActivatable

menuitem: Stop implementing GtkActivatable

Remove GtkTable

gtkwindow: Stop checking gtk-menu-bar-accel

button: Stop implementing GtkActivatable

button: Stop checking for GtkSettings:gtk-button-images setting

Stop checking GtkSettings:gtk-enable-mnemonics

widget: Remove push/pop_composite_child

as well as the composite-child property

widget: Remove gtk_widget_get_pointer

widget: Remove docs for style-set

widget: Remove gtk_widget_reparent

scrollbar: Remove style property

builtinicon: remove unused struct member

menuitem: Remove right-justify

label: Stop using GdkColor

cellrenderer: Remove cell-background-gdk

gtksettings: Remove Deprecated API

window: Remove reshow_with_initial_size

viewport: remove deprecated api

gtkdnd: Remove gtk_drag_begin

gtkmain: Remove deprecated key snooper API

treeview: Remove unused style properties

bbox: Remove style properties

gtkdialog: Remove style properties

colorbutton: Remove deprecated API

menu: Remove vertical/horizontal-offset style properties